package com.niit.scala

object Base_07 {

  def main(args: Array[String]): Unit = {
    /*
        函数式编程：方法的参数列表可以接收函数对象
     */
    //foreach
    var list1 = (1 to 9).toList
    //初级版
    list1.foreach( (x:Int) => println(x) )
    //升级版  Scala有类型推断的特性
    list1.foreach( x => println(x))
    //究极版： _:表示列表中每个元素。因为foreach 就是用来对列表进行遍历的，并且列表里面元素数值和类型不会发生任何改变，
    // 明知道这样，就可以把 参数都省略掉，直接用_来表示
    list1.foreach( println(_) )

    //map：集合的映射操作 将一个集合里面的元素进行转换 可能数据类型的转换，也可能是数值的转换
    //需求：某电影网站，需要观众对电影进行打分 等级 1 2 3 4 5 。。但是观众只能通过 * 的方式进行打分
    var list2 = List(1,2,3,4,5)
    //初级版
    var ll1 = list2.map( (x:Int) => "*" * x)
    println(ll1)
    //升级版
    var ll2 = list2.map( x => "*" * x)
    println(ll2)
    //究极版
    var ll3 = list2.map("*" * _)
    println(ll3)

    /*
    flatMap : map + flatten(扁平化   将列表中的所有子元素[列表  数组 元组 集] 合并成一个新的列表)
     */
    var list3 = List( "hadoop hive spark hbase",  "java python scala C/C++"  )
    //将上述列表变成   List(haoop,hive,spark,hbase,java,python,scala,C/C++)
    //拆解方式：
    //_: "hadoop hive spark hbase"
    val ll4: List[Array[String]] = list3.map(_.split(" ")) //split：按照指定格式对字符串进行分割，并返回一个数组
                 // 结果： List( Array(hadoop,hive,spark,hbase), Array(java,python,scala,C/C++)  )
                        /*
                             "hadoop hive spark hbase" 切割 ===   Array(hadoop,hive,spark,hbase)
                             "java python scala C/C++"  切割  ===  Array(java,python,scala,C/C++)

                             List( Array(hadoop,hive,spark,hbase),  Array(java,python,scala,C/C++) )
                         */
    val flatten: List[String] = ll4.flatten
    println(flatten)
    //合体方式：
    val ll5: List[String] = list3.flatMap(_.split(" ")) //参数是切割的条件
    println(ll5)


    //过滤：filter 过滤出符合一定条件的数据
    var list4 =(1 to 9).toList
    //将列表中过滤出能够被2整除的数据
    val ls1: List[Int] = list4.filter(_ % 2 == 0)//返回一个新的列表
    println(ls1)

    /*
    排序：
      sorted：对集合进行默认排序
      sortBy: 对集合指定字段排序
      sortWith:对集合进行自定义排序
     */
    //sorted
    var list5 =List(3,1,2,5,4,8,6,9,7)
    val ls2: List[Int] = list5.sorted
    println(ls2)
    val ls3: List[Int] = ls2.reverse//反转列表
    println(ls3)
    //sortBy         [01,hadoop]   [02,css] [03,java] [04,python]
    var list6 = List("01 hadoop","02 css","03 java","04 python")
    //按照字母的顺序进行排序
    val ls4: List[String] = list6.sortBy(_.split(" ")(1))
    println(ls4)
    //sortwith
    var list7 = List(3,1,2,5,4,8,6,9,7)
    //将list7进行降序排序
    val ls5: List[Int] = list7.sortWith((x, y) => x > y)
    println(ls5)
    // 此时x和y都是表示列表中的每一个元素，并且x和y也是固定位置，那么这样就习惯性找个东西来代替 第一个_表示x 第二个_表示y
    val ls6: List[Int] = list7.sortWith(_ > _)
    println(ls6)

    /*
    分组: 将集合按照指定条件进行分组 groupBy
    需求： 1.将一个班的学生按照性别进行分组
          2.统计不同性别人数
     */
    var list8 = List( ("张三","男"), ("李四","男"),("王五","女") )
    //按照性别进行分组
    val groupBy: Map[String, List[(String, String)]] = list8.groupBy(_._2)
    println(groupBy)
    // HashMap(  (男,  List((张三,男), (李四,男)) ),   (女 ,List((王五,女))     ))
    //最终结果Map ( (男，2),(女，2) )
    //  x _1:(男,  List((张三,男), (李四,男)) )
    //  x _2: (女 ,List((王五,女))
    //                                   1: (男,2)   2:(女,1)  === Map(  (男,2),  (女,1) )
    val res: Map[String, Int] = groupBy.map(x => (x._1, x._2.size))
    println(res)

    /*
     聚合操作
      reduce:用来集合元素进行聚合计算
      fold：用来集合元素进行折叠计算
     */
    var list9 = (1 to 10).toList
    var i1: Int = list9.reduce((x, y) => x + y)
    i1 = list9.reduce(_ + _)
    println(i1)
    //fold:和reduce一样，但是多个一个初始值参数
    //定义一个1-10的列表，假设初始值为100，使用fold进行累加
    val i2: Int = list9.fold(100)(_ + _)
    println(i2)
  }
}
